// 获取DOM元素
const chatMessages = document.getElementById('chat-messages');
const messageInput = document.getElementById('message-input');
const sendButton = document.getElementById('send-button');
const settingsButton = document.getElementById('settings-button'); // 添加设置按钮引用

// API配置 - 根据实际情况修改
const API_KEY = 'KQOFBQEBBIZCFT6EJMSCTZCQIKB2R9ZVAQEVWK1P'; // 替换为您的API密钥
const API_URL = 'https://ai.gitee.com/api/v1/chat/completions';

// 存储聊天历史记录，用于构建完整的上下文
let chatHistory = [
    { role: 'system', content: '你是一个古风草原悍将，名叫赫连赫苍，你粗犷豪迈，嘴里偶尔会冒出脏话，一切处事逻辑都很粗暴，（笑了笑）原来是个中原小毛孩，他妈的事情真多（手中长刀仍在你面前）来，练练手！' }
];

// 处理括号内容，将其标记为特定样式
function processBracketContent(text) {
    // 处理圆括号内容 - 修复替换逻辑
    text = text.replace(/\(([^()]+)\)/g, '<span class="bracket-content">($1)</span>');
    // 处理方括号内容 - 修复替换逻辑
    text = text.replace(/\[([^\[\]]+)\]/g, '<span class="bracket-content">[$1]</span>');
    // 处理中文括号内容
    text = text.replace(/\（([^\（\）]+)\）/g, '<span class="bracket-content">（$1）</span>');
    return text;
}

// 添加消息到聊天区域
function addMessage(text, type) {
    const messageDiv = document.createElement('div');
    messageDiv.classList.add('message', type);
    
    const now = new Date();
    const timeString = `${now.getHours().toString().padStart(2, '0')}:${now.getMinutes().toString().padStart(2, '0')}`;
    
    // 处理括号内容
    const processedText = processBracketContent(text);
    
    messageDiv.innerHTML = `
        <div class="message-content">
            <p>${processedText}</p>
            <div class="message-time">${type === 'sent' ? '我' : '对方'}</div>
        </div>
    `;
    
    chatMessages.appendChild(messageDiv);
    
    // 滚动到底部
    chatMessages.scrollTop = chatMessages.scrollHeight;
}

// 添加"正在输入"指示器
function showTypingIndicator() {
    // 先检查是否已经存在typing indicator
    const existingIndicator = document.querySelector('.typing-indicator');
    if (existingIndicator) {
        return;
    }
    
    const indicatorDiv = document.createElement('div');
    indicatorDiv.classList.add('message', 'received');
    indicatorDiv.innerHTML = `
        <div class="message-content typing-indicator">
            <div class="typing-dot"></div>
            <div class="typing-dot"></div>
            <div class="typing-dot"></div>
        </div>
    `;
    
    chatMessages.appendChild(indicatorDiv);
    chatMessages.scrollTop = chatMessages.scrollHeight;
    
    return indicatorDiv;
}

// 移除"正在输入"指示器
function removeTypingIndicator() {
    const indicator = document.querySelector('.typing-indicator');
    if (indicator && indicator.parentElement) {
        chatMessages.removeChild(indicator.parentElement);
    }
}

// 验证API配置
function validateApiConfig() {
    if (!API_KEY || API_KEY === 'your_api_key') {
        return { valid: false, message: 'API密钥未配置，请设置有效的API密钥' };
    }
    if (!API_URL) {
        return { valid: false, message: 'API端点URL未配置' };
    }
    return { valid: true };
}

// 流式接收API回复
async function streamReply(userMessage) {
    // 显示"正在输入"指示器
    showTypingIndicator();
    
    try {
        // 验证API配置
        const configValidation = validateApiConfig();
        if (!configValidation.valid) {
            throw new Error(configValidation.message);
        }
        
        // 准备请求体 - 使用完整的聊天历史记录作为上下文
        const requestBody = {
            model: 'DeepSeek-V3', // 模型名称
            messages: [...chatHistory], // 使用完整的聊天历史记录
            stream: true, // 启用流式响应
            max_tokens: 1000,
            temperature: 0.7 // 添加温度参数，使回复更加自然
        };
        
        console.log('准备发送API请求:', {
            url: API_URL,
            headers: {
                'Content-Type': 'application/json',
                'Authorization': `Bearer ${API_KEY.substring(0, 5)}...` // 仅显示部分API密钥以保护安全
            },
            requestBody: requestBody
        });
        
        // 发送API请求
        const response = await fetch(API_URL, {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'Authorization': `Bearer ${API_KEY}`
            },
            body: JSON.stringify(requestBody),
            credentials: 'omit' // 不发送cookie
        });
        
        if (!response.ok) {
            // 尝试获取详细的错误信息
            let errorDetails = '';
            try {
                const errorJson = await response.json();
                errorDetails = errorJson.error ? ` - ${errorJson.error.message || JSON.stringify(errorJson.error)}` : '';
            } catch (e) {
                // 如果无法解析错误信息，就继续使用基本错误
            }
            
            // 根据不同错误类型提供更具体的错误信息
            if (response.status === 400) {
                throw new Error(`请求格式错误: API无法理解您的请求${errorDetails}\n可能是请求参数错误或API端点不正确`);
            } else if (response.status === 401) {
                throw new Error(`API认证失败: 请检查您的API密钥是否正确或已过期${errorDetails}`);
            } else if (response.status === 403) {
                throw new Error(`访问被拒绝: 您没有权限访问此API或模型${errorDetails}`);
            } else if (response.status === 404) {
                throw new Error(`API端点不存在: 请求的URL可能不正确${errorDetails}`);
            } else if (response.status === 429) {
                throw new Error(`API请求过于频繁: 请稍后再试${errorDetails}`);
            } else if (response.status === 500) {
                throw new Error(`服务器内部错误: API服务暂时不可用${errorDetails}`);
            } else {
                throw new Error(`API请求失败: ${response.status} ${response.statusText}${errorDetails}`);
            }
        }
        
        // 移除"正在输入"指示器
        removeTypingIndicator();
        
        // 创建用于显示流式回复的元素
        const messageDiv = document.createElement('div');
        messageDiv.classList.add('message', 'received');
        
        const contentDiv = document.createElement('div');
        contentDiv.classList.add('message-content');
        
        const textParagraph = document.createElement('p');
        contentDiv.appendChild(textParagraph);
        
        const now = new Date();
        const timeString = `${now.getHours().toString().padStart(2, '0')}:${now.getMinutes().toString().padStart(2, '0')}`;
        
        const timeDiv = document.createElement('div');
        timeDiv.classList.add('message-time');
        timeDiv.textContent = '对方';
        contentDiv.appendChild(timeDiv);
        
        messageDiv.appendChild(contentDiv);
        chatMessages.appendChild(messageDiv);
        chatMessages.scrollTop = chatMessages.scrollHeight;
        
        // 处理流式响应
        const reader = response.body.getReader();
        const decoder = new TextDecoder();
        let fullText = '';
        let tempText = '';
        
        // 持续读取流数据
        while (true) {
            const { done, value } = await reader.read();
            if (done) break;
            
            const chunk = decoder.decode(value, { stream: true });
            
            // 解析chunk中的JSON数据（可能包含多个事件）
            const lines = chunk.split('\n');
            for (const line of lines) {
                if (line.trim() === '') continue;
                if (line.startsWith('data:')) {
                    const data = line.substring(5).trim();
                    if (data === '[DONE]') continue;
                    
                    try {
                        const event = JSON.parse(data);
                        if (event.choices && event.choices[0] && event.choices[0].delta) {
                            const delta = event.choices[0].delta;
                            if (delta.content) {
                                fullText += delta.content;
                                tempText += delta.content;
                                // 修复：始终使用innerHTML并处理括号内容，避免文本更新不完整
                                textParagraph.innerHTML = processBracketContent(fullText);
                                chatMessages.scrollTop = chatMessages.scrollHeight;
                            }
                        }
                    } catch (e) {
                        console.error('解析流式响应失败:', e);
                        console.log('问题chunk:', line);
                    }
                }
            }
        }
        
        // 确保最后剩余的文本也被处理
        if (tempText) {
            textParagraph.innerHTML = processBracketContent(fullText);
        }
        
        // 将AI回复添加到聊天历史记录
        if (fullText.trim()) {
            chatHistory.push({ role: 'assistant', content: fullText });
        }
        
    } catch (error) {
        console.error('获取回复失败:', error);
        // 移除"正在输入"指示器
        removeTypingIndicator();
        // 显示错误消息并提供建议
        let errorMessage = `抱歉，获取回复失败: ${error.message}`;
        let suggestion = '';
        
        if (error.message.includes('请求格式错误')) {
            suggestion = '\n建议检查API端点是否正确或请求参数是否符合要求。';
        } else if (error.message.includes('API认证失败')) {
            suggestion = '\n请确认您的API密钥是否正确配置。';
        } else if (error.message.includes('API请求过于频繁')) {
            suggestion = '\n建议减少请求频率或稍后再试。';
        } else if (error.message.includes('服务器内部错误')) {
            suggestion = '\n这可能是临时性问题，请稍后再试。';
        } else if (error.message.includes('API端点不存在')) {
            suggestion = '\n请确认您使用的API端点URL是否正确。';
        }
        
        addMessage(errorMessage + suggestion, 'received');
    }
}

// 打字机效果函数（仅用于AI回复）
function typewriterEffect(text, type) {
    const messageDiv = document.createElement('div');
    messageDiv.classList.add('message', type);
    
    const contentDiv = document.createElement('div');
    contentDiv.classList.add('message-content');
    
    const textParagraph = document.createElement('p');
    contentDiv.appendChild(textParagraph);
    
    const now = new Date();
    const timeString = `${now.getHours().toString().padStart(2, '0')}:${now.getMinutes().toString().padStart(2, '0')}`;
    
    const timeDiv = document.createElement('div');
    timeDiv.classList.add('message-time');
    timeDiv.textContent = type === 'sent' ? '我' : '对方';
    contentDiv.appendChild(timeDiv);
    
    messageDiv.appendChild(contentDiv);
    chatMessages.appendChild(messageDiv);
    chatMessages.scrollTop = chatMessages.scrollHeight;
    
    let index = 0;
    const typingSpeed = 30 + Math.random() * 50; // 30-80ms per character
    let tempText = '';
    
    function typeNextChar() {
        if (index < text.length) {
            tempText += text.charAt(index);
            index++;
            
            // 只有当累积到足够的文本或检测到句子结束时才处理括号
            if (tempText.length > 50 || /[。.!,，]/.test(tempText.slice(-1))) {
                textParagraph.innerHTML = processBracketContent(tempText);
            } else {
                textParagraph.textContent = tempText;
            }
            
            setTimeout(typeNextChar, typingSpeed);
        } else {
            // 确保最后剩余的文本也被处理
            textParagraph.innerHTML = processBracketContent(tempText);
            
            // 打字机效果完成后，将AI回复添加到聊天历史记录
            if (type === 'received') {
                chatHistory.push({ role: 'assistant', content: text });
            }
        }
    }
    
    // 开始打字效果
    setTimeout(typeNextChar, 100);
}

// 事件监听
sendButton.addEventListener('click', sendMessage);

messageInput.addEventListener('keypress', (e) => {
    if (e.key === 'Enter') {
        sendMessage();
    }
});

// 发送消息
function sendMessage() {
    const message = messageInput.value.trim();
    if (message) {
        // 用户消息直接显示，不使用打字机效果
        addMessage(message, 'sent');
        messageInput.value = '';
        
        // 将用户消息添加到聊天历史记录
        chatHistory.push({ role: 'user', content: message });
        
        // 使用流式API获取回复
        streamReply(message);
    }
}

// 输入框状态监听
messageInput.addEventListener('input', () => {
    sendButton.disabled = messageInput.value.trim() === '';
});

// 初始化按钮状态
sendButton.disabled = true;

// 添加页面加载动画
window.addEventListener('load', () => {
    document.body.style.opacity = '0';
    setTimeout(() => {
        document.body.style.transition = 'opacity 0.5s ease';
        document.body.style.opacity = '1';
    }, 100);
});

// 页面加载完成后，检查API配置并提示用户
window.addEventListener('load', () => {
    const configValidation = validateApiConfig();
    if (!configValidation.valid) {
        console.warn('API配置检查:', configValidation.message);
        // 不直接在界面显示警告，以免影响用户体验
    }
});

// 添加设置按钮点击事件
settingsButton.addEventListener('click', function() {
    console.log('设置按钮被点击');
    
    try {
        // 打开设置窗口
        const settingsWindow = window.open(
            'settings.html', 
            'settingsWindow', 
            'width=350,height=450,toolbar=no,scrollbars=yes,resizable=yes'
        );
        
        if (settingsWindow === null || typeof settingsWindow === 'undefined') {
            console.error('窗口打开失败，可能被浏览器阻止');
            alert('无法打开设置窗口，可能被浏览器安全设置阻止');
        } else {
            console.log('设置窗口已创建');
            
            // 确保窗口在最前面
            settingsWindow.focus();
            console.log('已尝试将窗口置于焦点');
        }
    } catch (error) {
        console.error('打开设置窗口时发生错误:', error);
        alert('打开设置窗口时发生错误: ' + error.message);
    }
});

// 监听来自设置窗口的消息
window.addEventListener('message', function(event) {
    if (event.data && event.data.type === 'settings_saved') {
        console.log('设置已保存:', event.data.settings);
        // 这里可以根据保存的设置更新主窗口的行为
        applySettings(event.data.settings);
    }
});

// 应用设置
function applySettings(settings) {
    // 这里可以根据实际需求实现设置的应用
    console.log('应用设置:', settings);
    
    // 设置窗口置顶
    if (typeof window.external !== 'undefined' && typeof window.external.setAlwaysOnTop === 'function') {
        window.external.setAlwaysOnTop(settings.stayOnTop);
        console.log('已调用window.external.setAlwaysOnTop');
    } else {
        console.error('window.external.setAlwaysOnTop 函数不可用');
    }
    
    // 示例：设置响应速度
    switch(settings.responseSpeed) {
        case 'fast':
            // 实现快速响应
            break;
        case 'normal':
            // 实现正常响应
            break;
        case 'slow':
            // 实现慢速响应
            break;
    }
}